home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / Memory.p < prev    next >
Encoding:
Text File  |  1996-05-01  |  15.6 KB  |  600 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Memory.p
  3.  
  4.      Contains:    Memory Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {
  19.  NOTE
  20.  
  21.  Don’t change GetHandleSize and GetPtrSize into inlines.  They are documented as returning
  22.  0 in case of an error in Inside Mac, but the traps actually return an error code in D0.
  23.  The glue sets D0 to 0 if an error occured.
  24. }
  25. {$IFC UNDEFINED UsingIncludes}
  26. {$SETC UsingIncludes := 0}
  27. {$ENDC}
  28.  
  29. {$IFC NOT UsingIncludes}
  30.  UNIT Memory;
  31.  INTERFACE
  32. {$ENDC}
  33.  
  34. {$IFC UNDEFINED __MEMORY__}
  35. {$SETC __MEMORY__ := 1}
  36.  
  37. {$I+}
  38. {$SETC MemoryIncludes := UsingIncludes}
  39. {$SETC UsingIncludes := 1}
  40.  
  41. {$IFC UNDEFINED __TYPES__}
  42. {$I Types.p}
  43. {$ENDC}
  44. {$IFC UNDEFINED __MIXEDMODE__}
  45. {$I MixedMode.p}
  46. {$ENDC}
  47.  
  48. {$PUSH}
  49. {$ALIGN MAC68K}
  50. {$LibExport+}
  51.  
  52.  
  53. CONST
  54.     maxSize                        = $00800000;                    { Max data block size is 8 megabytes }
  55.     defaultPhysicalEntryCount    = 8;                            {  values returned from the GetPageState function  }
  56.     kPageInMemory                = 0;
  57.     kPageOnDisk                    = 1;
  58.     kNotPaged                    = 2;
  59.  
  60.                                                                 {  masks for Zone->heapType field  }
  61.     k32BitHeap                    = 1;                            {  valid in all Memory Managers  }
  62.     kNewStyleHeap                = 2;                            {  true if new Heap Manager is present  }
  63.     kNewDebugHeap                = 4;                            {  true if new Heap Manager is running in debug mode on this heap  }
  64.  
  65. {  size of a block in bytes  }
  66.  
  67. TYPE
  68.     Size                                = LONGINT;
  69. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  70.     GrowZoneProcPtr = ProcPtr;  { FUNCTION GrowZone(cbNeeded: Size): LONGINT; }
  71.  
  72.     PurgeProcPtr = ProcPtr;  { PROCEDURE Purge(blockToPurge: Handle); }
  73.  
  74.     UserFnProcPtr = Register68kProcPtr;  { PROCEDURE UserFn(parameter: UNIV Ptr); }
  75.  
  76.     GrowZoneUPP = UniversalProcPtr;
  77.     PurgeUPP = UniversalProcPtr;
  78.     UserFnUPP = UniversalProcPtr;
  79.     ZonePtr = ^Zone;
  80.     Zone = RECORD
  81.         bkLim:                    Ptr;
  82.         purgePtr:                Ptr;
  83.         hFstFree:                Ptr;
  84.         zcbFree:                LONGINT;
  85.         gzProc:                    GrowZoneUPP;
  86.         moreMast:                INTEGER;
  87.         flags:                    INTEGER;
  88.         cntRel:                    INTEGER;
  89.         maxRel:                    INTEGER;
  90.         cntNRel:                INTEGER;
  91.         heapType:                SInt8;                                    {  previously "maxNRel", now holds flags (e.g. k32BitHeap) }
  92.         unused:                    SInt8;
  93.         cntEmpty:                INTEGER;
  94.         cntHandles:                INTEGER;
  95.         minCBFree:                LONGINT;
  96.         purgeProc:                PurgeUPP;
  97.         sparePtr:                Ptr;
  98.         allocPtr:                Ptr;
  99.         heapData:                INTEGER;
  100.     END;
  101.  
  102.     THz                                    = ^Zone;
  103.     MemoryBlockPtr = ^MemoryBlock;
  104.     MemoryBlock = RECORD
  105.         address:                Ptr;
  106.         count:                    LONGINT;
  107.     END;
  108.  
  109.     LogicalToPhysicalTablePtr = ^LogicalToPhysicalTable;
  110.     LogicalToPhysicalTable = RECORD
  111.         logical:                MemoryBlock;
  112.         physical:                ARRAY [0..7] OF MemoryBlock;
  113.     END;
  114.  
  115.     PageState                            = INTEGER;
  116.     StatusRegisterContents                = INTEGER;
  117.  
  118. CONST
  119.     uppGrowZoneProcInfo = $000000F0;
  120.     uppPurgeProcInfo = $000000C0;
  121.     uppUserFnProcInfo = $00009802;
  122.  
  123. FUNCTION NewGrowZoneProc(userRoutine: GrowZoneProcPtr): GrowZoneUPP;
  124.     {$IFC NOT GENERATINGCFM }
  125.     INLINE $2E9F;
  126.     {$ENDC}
  127.  
  128. FUNCTION NewPurgeProc(userRoutine: PurgeProcPtr): PurgeUPP;
  129.     {$IFC NOT GENERATINGCFM }
  130.     INLINE $2E9F;
  131.     {$ENDC}
  132.  
  133. FUNCTION NewUserFnProc(userRoutine: UserFnProcPtr): UserFnUPP;
  134.     {$IFC NOT GENERATINGCFM }
  135.     INLINE $2E9F;
  136.     {$ENDC}
  137.  
  138. FUNCTION CallGrowZoneProc(cbNeeded: Size; userRoutine: GrowZoneUPP): LONGINT;
  139.     {$IFC NOT GENERATINGCFM}
  140.     INLINE $205F, $4E90;
  141.     {$ENDC}
  142.  
  143. PROCEDURE CallPurgeProc(blockToPurge: Handle; userRoutine: PurgeUPP);
  144.     {$IFC NOT GENERATINGCFM}
  145.     INLINE $205F, $4E90;
  146.     {$ENDC}
  147.  
  148. PROCEDURE CallUserFnProc(parameter: UNIV Ptr; userRoutine: UserFnUPP);
  149.     {$IFC NOT GENERATINGCFM}
  150.     {To be implemented:  Glue to move parameters into registers.}
  151.     {$ENDC}
  152. FUNCTION GetApplLimit: Ptr;
  153.     {$IFC NOT GENERATINGCFM}
  154.     INLINE $2EB8, $0130;
  155.     {$ENDC}
  156. FUNCTION SystemZone: THz;
  157.     {$IFC NOT GENERATINGCFM}
  158.     INLINE $2EB8, $02A6;
  159.     {$ENDC}
  160. FUNCTION ApplicationZone: THz;
  161.     {$IFC NOT GENERATINGCFM}
  162.     INLINE $2EB8, $02AA;
  163.     {$ENDC}
  164. FUNCTION GZSaveHnd: Handle;
  165.     {$IFC NOT GENERATINGCFM}
  166.     INLINE $2EB8, $0328;
  167.     {$ENDC}
  168. FUNCTION TopMem: Ptr;
  169.     {$IFC NOT GENERATINGCFM}
  170.     INLINE $2EB8, $0108;
  171.     {$ENDC}
  172. FUNCTION MemError: OSErr;
  173.     {$IFC NOT GENERATINGCFM}
  174.     INLINE $3EB8, $0220;
  175.     {$ENDC}
  176. {$ENDC}
  177. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  178. FUNCTION GetZone: THz;
  179.     {$IFC NOT GENERATINGCFM}
  180.     INLINE $A11A, $2E88;
  181.     {$ENDC}
  182. FUNCTION NewHandle(byteCount: Size): Handle;
  183.     {$IFC NOT GENERATINGCFM}
  184.     INLINE $201F, $A122, $2E88;
  185.     {$ENDC}
  186. FUNCTION NewHandleSys(byteCount: Size): Handle;
  187.     {$IFC NOT GENERATINGCFM}
  188.     INLINE $201F, $A522, $2E88;
  189.     {$ENDC}
  190. FUNCTION NewHandleClear(byteCount: Size): Handle;
  191.     {$IFC NOT GENERATINGCFM}
  192.     INLINE $201F, $A322, $2E88;
  193.     {$ENDC}
  194. FUNCTION NewHandleSysClear(byteCount: Size): Handle;
  195.     {$IFC NOT GENERATINGCFM}
  196.     INLINE $201F, $A722, $2E88;
  197.     {$ENDC}
  198. FUNCTION HandleZone(h: Handle): THz;
  199.     {$IFC NOT GENERATINGCFM}
  200.     INLINE $205F, $A126, $2E88;
  201.     {$ENDC}
  202. FUNCTION RecoverHandle(p: Ptr): Handle;
  203.     {$IFC NOT GENERATINGCFM}
  204.     INLINE $205F, $A128, $2E88;
  205.     {$ENDC}
  206. FUNCTION RecoverHandleSys(p: Ptr): Handle;
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $205F, $A528, $2E88;
  209.     {$ENDC}
  210. FUNCTION NewPtr(byteCount: Size): Ptr;
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $201F, $A11E, $2E88;
  213.     {$ENDC}
  214. FUNCTION NewPtrSys(byteCount: Size): Ptr;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $201F, $A51E, $2E88;
  217.     {$ENDC}
  218. FUNCTION NewPtrClear(byteCount: Size): Ptr;
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $201F, $A31E, $2E88;
  221.     {$ENDC}
  222. FUNCTION NewPtrSysClear(byteCount: Size): Ptr;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $201F, $A71E, $2E88;
  225.     {$ENDC}
  226. FUNCTION PtrZone(p: Ptr): THz;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $205F, $A148, $2E88;
  229.     {$ENDC}
  230. FUNCTION MaxBlock: LONGINT;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $A061, $2E80;
  233.     {$ENDC}
  234. FUNCTION MaxBlockSys: LONGINT;
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $A461, $2E80;
  237.     {$ENDC}
  238. FUNCTION StackSpace: LONGINT;
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $A065, $2E80;
  241.     {$ENDC}
  242. FUNCTION NewEmptyHandle: Handle;
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $A166, $2E88;
  245.     {$ENDC}
  246. FUNCTION NewEmptyHandleSys: Handle;
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $A566, $2E88;
  249.     {$ENDC}
  250. PROCEDURE HLock(h: Handle);
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $205F, $A029;
  253.     {$ENDC}
  254. PROCEDURE HUnlock(h: Handle);
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $205F, $A02A;
  257.     {$ENDC}
  258. PROCEDURE HPurge(h: Handle);
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $205F, $A049;
  261.     {$ENDC}
  262. PROCEDURE HNoPurge(h: Handle);
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $205F, $A04A;
  265.     {$ENDC}
  266. PROCEDURE HLockHi(h: Handle);
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $205F, $A064, $A029;
  269.     {$ENDC}
  270. FUNCTION TempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $3F3C, $001D, $A88F;
  273.     {$ENDC}
  274. FUNCTION TempMaxMem(VAR grow: Size): Size;
  275.     {$IFC NOT GENERATINGCFM}
  276.     INLINE $3F3C, $0015, $A88F;
  277.     {$ENDC}
  278. FUNCTION TempFreeMem: LONGINT;
  279.     {$IFC NOT GENERATINGCFM}
  280.     INLINE $3F3C, $0018, $A88F;
  281.     {$ENDC}
  282. PROCEDURE InitZone(pgrowZone: GrowZoneUPP; cmoreMasters: INTEGER; limitPtr: UNIV Ptr; startPtr: UNIV Ptr);
  283. PROCEDURE SetZone(hz: THz);
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $205F, $A01B;
  286.     {$ENDC}
  287. FUNCTION CompactMem(cbNeeded: Size): Size;
  288.     {$IFC NOT GENERATINGCFM}
  289.     INLINE $201F, $A04C, $2E80;
  290.     {$ENDC}
  291. FUNCTION CompactMemSys(cbNeeded: Size): Size;
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $201F, $A44C, $2E80;
  294.     {$ENDC}
  295. PROCEDURE PurgeMem(cbNeeded: Size);
  296.     {$IFC NOT GENERATINGCFM}
  297.     INLINE $201F, $A04D;
  298.     {$ENDC}
  299. PROCEDURE PurgeMemSys(cbNeeded: Size);
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $201F, $A44D;
  302.     {$ENDC}
  303. FUNCTION FreeMem: LONGINT;
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $A01C, $2E80;
  306.     {$ENDC}
  307. FUNCTION FreeMemSys: LONGINT;
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $A41C, $2E80;
  310.     {$ENDC}
  311. PROCEDURE ReserveMem(cbNeeded: Size);
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $201F, $A040;
  314.     {$ENDC}
  315. PROCEDURE ReserveMemSys(cbNeeded: Size);
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $201F, $A440;
  318.     {$ENDC}
  319. FUNCTION MaxMem(VAR grow: Size): Size;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $225F, $A11D, $2288, $2E80;
  322.     {$ENDC}
  323. FUNCTION MaxMemSys(VAR grow: Size): Size;
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $225F, $A51D, $2288, $2E80;
  326.     {$ENDC}
  327. PROCEDURE SetGrowZone(growZone: GrowZoneUPP);
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $205F, $A04B;
  330.     {$ENDC}
  331. PROCEDURE MoveHHi(h: Handle);
  332.     {$IFC NOT GENERATINGCFM}
  333.     INLINE $205F, $A064;
  334.     {$ENDC}
  335. PROCEDURE DisposePtr(p: Ptr);
  336.     {$IFC NOT GENERATINGCFM}
  337.     INLINE $205F, $A01F;
  338.     {$ENDC}
  339. FUNCTION GetPtrSize(p: Ptr): Size;
  340. PROCEDURE SetPtrSize(p: Ptr; newSize: Size);
  341.     {$IFC NOT GENERATINGCFM}
  342.     INLINE $201F, $205F, $A020;
  343.     {$ENDC}
  344. PROCEDURE DisposeHandle(h: Handle);
  345.     {$IFC NOT GENERATINGCFM}
  346.     INLINE $205F, $A023;
  347.     {$ENDC}
  348. PROCEDURE SetHandleSize(h: Handle; newSize: Size);
  349.     {$IFC NOT GENERATINGCFM}
  350.     INLINE $201F, $205F, $A024;
  351.     {$ENDC}
  352. FUNCTION GetHandleSize(h: Handle): Size;
  353. FUNCTION InlineGetHandleSize(h: Handle): Size;
  354.     {$IFC NOT GENERATINGCFM}
  355.     INLINE $205F, $A025, $2E80;
  356.     {$ENDC}
  357. PROCEDURE ReallocateHandle(h: Handle; byteCount: Size);
  358.     {$IFC NOT GENERATINGCFM}
  359.     INLINE $201F, $205F, $A027;
  360.     {$ENDC}
  361. PROCEDURE ReallocateHandleSys(h: Handle; byteCount: Size);
  362.     {$IFC NOT GENERATINGCFM}
  363.     INLINE $201F, $205F, $A427;
  364.     {$ENDC}
  365. PROCEDURE EmptyHandle(h: Handle);
  366.     {$IFC NOT GENERATINGCFM}
  367.     INLINE $205F, $A02B;
  368.     {$ENDC}
  369. PROCEDURE HSetRBit(h: Handle);
  370.     {$IFC NOT GENERATINGCFM}
  371.     INLINE $205F, $A067;
  372.     {$ENDC}
  373. PROCEDURE HClrRBit(h: Handle);
  374.     {$IFC NOT GENERATINGCFM}
  375.     INLINE $205F, $A068;
  376.     {$ENDC}
  377. FUNCTION HGetState(h: Handle): SInt8;
  378.     {$IFC NOT GENERATINGCFM}
  379.     INLINE $205F, $A069, $1E80;
  380.     {$ENDC}
  381. PROCEDURE HSetState(h: Handle; flags: SInt8);
  382.     {$IFC NOT GENERATINGCFM}
  383.     INLINE $101F, $205F, $A06A;
  384.     {$ENDC}
  385. PROCEDURE PurgeSpace(VAR total: LONGINT; VAR contig: LONGINT);
  386. {$ENDC}
  387. {$IFC FOR_SYSTEM7_ONLY }
  388. {  These are defined in Kernel for System 8  }
  389. PROCEDURE BlockMove(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  390.     {$IFC NOT GENERATINGCFM}
  391.     INLINE $201F, $225F, $205F, $A02E;
  392.     {$ENDC}
  393. PROCEDURE BlockMoveData(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  394.     {$IFC NOT GENERATINGCFM}
  395.     INLINE $201F, $225F, $205F, $A22E;
  396.     {$ENDC}
  397. PROCEDURE BlockMoveUncached(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size); C;
  398. PROCEDURE BlockMoveDataUncached(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size); C;
  399. PROCEDURE BlockZero(destPtr: UNIV Ptr; byteCount: Size); C;
  400. PROCEDURE BlockZeroUncached(destPtr: UNIV Ptr; byteCount: Size); C;
  401. {$ENDC}
  402. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  403. PROCEDURE MaxApplZone;
  404.     {$IFC NOT GENERATINGCFM}
  405.     INLINE $A063;
  406.     {$ENDC}
  407. PROCEDURE SetApplBase(startPtr: UNIV Ptr);
  408.     {$IFC NOT GENERATINGCFM}
  409.     INLINE $205F, $A057;
  410.     {$ENDC}
  411. PROCEDURE MoreMasters;
  412.     {$IFC NOT GENERATINGCFM}
  413.     INLINE $A036;
  414.     {$ENDC}
  415. PROCEDURE SetApplLimit(zoneLimit: UNIV Ptr);
  416.     {$IFC NOT GENERATINGCFM}
  417.     INLINE $205F, $A02D;
  418.     {$ENDC}
  419. {$ENDC}
  420. {$IFC FOR_SYSTEM7_ONLY }
  421. PROCEDURE InitApplZone;
  422.     {$IFC NOT GENERATINGCFM}
  423.     INLINE $A02C;
  424.     {$ENDC}
  425. {$ENDC}
  426. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  427. {   Temporary Memory routines renamed, but obsolete, in System 7.0 and later.   }
  428. PROCEDURE TempHLock(h: Handle; VAR resultCode: OSErr);
  429.     {$IFC NOT GENERATINGCFM}
  430.     INLINE $3F3C, $001E, $A88F;
  431.     {$ENDC}
  432. PROCEDURE TempHUnlock(h: Handle; VAR resultCode: OSErr);
  433.     {$IFC NOT GENERATINGCFM}
  434.     INLINE $3F3C, $001F, $A88F;
  435.     {$ENDC}
  436. PROCEDURE TempDisposeHandle(h: Handle; VAR resultCode: OSErr);
  437.     {$IFC NOT GENERATINGCFM}
  438.     INLINE $3F3C, $0020, $A88F;
  439.     {$ENDC}
  440. FUNCTION TempTopMem: Ptr;
  441.     {$IFC NOT GENERATINGCFM}
  442.     INLINE $3F3C, $0016, $A88F;
  443.     {$ENDC}
  444. {$ENDC}
  445. {$IFC FOR_SYSTEM7_ONLY }
  446. FUNCTION HoldMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  447.     {$IFC NOT GENERATINGCFM}
  448.     INLINE $225F, $205F, $7000, $A05C, $3E80;
  449.     {$ENDC}
  450. FUNCTION UnholdMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  451.     {$IFC NOT GENERATINGCFM}
  452.     INLINE $225F, $205F, $7001, $A05C, $3E80;
  453.     {$ENDC}
  454. FUNCTION LockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  455.     {$IFC NOT GENERATINGCFM}
  456.     INLINE $225F, $205F, $7002, $A05C, $3E80;
  457.     {$ENDC}
  458. FUNCTION LockMemoryContiguous(address: UNIV Ptr; count: LONGINT): OSErr;
  459.     {$IFC NOT GENERATINGCFM}
  460.     INLINE $225F, $205F, $7004, $A05C, $3E80;
  461.     {$ENDC}
  462. FUNCTION UnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  463.     {$IFC NOT GENERATINGCFM}
  464.     INLINE $225F, $205F, $7003, $A05C, $3E80;
  465.     {$ENDC}
  466. FUNCTION GetPhysical(VAR addresses: LogicalToPhysicalTable; VAR physicalEntryCount: LONGINT): OSErr;
  467. FUNCTION DeferUserFn(userFunction: UserFnUPP; argument: UNIV Ptr): OSErr;
  468.     {$IFC NOT GENERATINGCFM}
  469.     INLINE $201F, $205F, $A08F, $3E80;
  470.     {$ENDC}
  471. FUNCTION DebuggerGetMax: LONGINT;
  472.     {$IFC NOT GENERATINGCFM}
  473.     INLINE $7000, $A08D, $2E80;
  474.     {$ENDC}
  475. PROCEDURE DebuggerEnter;
  476.     {$IFC NOT GENERATINGCFM}
  477.     INLINE $7001, $A08D;
  478.     {$ENDC}
  479. PROCEDURE DebuggerExit;
  480.     {$IFC NOT GENERATINGCFM}
  481.     INLINE $7002, $A08D;
  482.     {$ENDC}
  483. PROCEDURE DebuggerPoll;
  484.     {$IFC NOT GENERATINGCFM}
  485.     INLINE $7003, $A08D;
  486.     {$ENDC}
  487. FUNCTION GetPageState(address: UNIV Ptr): PageState;
  488.     {$IFC NOT GENERATINGCFM}
  489.     INLINE $205F, $7004, $A08D, $3E80;
  490.     {$ENDC}
  491. FUNCTION PageFaultFatal: BOOLEAN;
  492.     {$IFC NOT GENERATINGCFM}
  493.     INLINE $7005, $A08D, $1E80;
  494.     {$ENDC}
  495. FUNCTION DebuggerLockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  496.     {$IFC NOT GENERATINGCFM}
  497.     INLINE $225F, $205F, $7006, $A08D, $3E80;
  498.     {$ENDC}
  499. FUNCTION DebuggerUnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  500.     {$IFC NOT GENERATINGCFM}
  501.     INLINE $225F, $205F, $7007, $A08D, $3E80;
  502.     {$ENDC}
  503. FUNCTION EnterSupervisorMode: StatusRegisterContents;
  504.     {$IFC NOT GENERATINGCFM}
  505.     INLINE $7008, $A08D, $3E80;
  506.     {$ENDC}
  507. {$ENDC}
  508. {
  509.  StripAddress and Translate24To32 macro to nothing on PowerPC
  510.    StripAddress is implemented as a trap in System 6 or later 
  511. }
  512. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  513.     {$IFC NOT GENERATINGCFM}
  514.     INLINE $201F, $A055, $2E80;
  515.     {$ENDC}
  516. FUNCTION Translate24To32(addr24: UNIV Ptr): Ptr;
  517.     {$IFC NOT GENERATINGCFM}
  518.     INLINE $201F, $A091, $2E80;
  519.     {$ENDC}
  520. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  521. FUNCTION HandToHand(VAR theHndl: Handle): OSErr;
  522. FUNCTION PtrToXHand(srcPtr: UNIV Ptr; dstHndl: Handle; size: LONGINT): OSErr;
  523.     {$IFC NOT GENERATINGCFM}
  524.     INLINE $201F, $225F, $205F, $A9E2, $3E80;
  525.     {$ENDC}
  526. FUNCTION PtrToHand(srcPtr: UNIV Ptr; VAR dstHndl: Handle; size: LONGINT): OSErr;
  527. FUNCTION HandAndHand(hand1: Handle; hand2: Handle): OSErr;
  528.     {$IFC NOT GENERATINGCFM}
  529.     INLINE $225F, $205F, $A9E4, $3E80;
  530.     {$ENDC}
  531. FUNCTION PtrAndHand(ptr1: UNIV Ptr; hand2: Handle; size: LONGINT): OSErr;
  532.     {$IFC NOT GENERATINGCFM}
  533.     INLINE $201F, $225F, $205F, $A9EF, $3E80;
  534.     {$ENDC}
  535. {$ENDC}
  536. {$IFC OLDROUTINENAMES }
  537. {$IFC FOR_SYSTEM7_ONLY }
  538. FUNCTION ApplicZone: THz;
  539.     {$IFC NOT GENERATINGCFM}
  540.     INLINE $2EB8, $02AA;
  541.     {$ENDC}
  542. FUNCTION MFTempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  543.     {$IFC NOT GENERATINGCFM}
  544.     INLINE $3F3C, $001D, $A88F;
  545.     {$ENDC}
  546. FUNCTION MFMaxMem(VAR grow: Size): Size;
  547.     {$IFC NOT GENERATINGCFM}
  548.     INLINE $3F3C, $0015, $A88F;
  549.     {$ENDC}
  550. FUNCTION MFFreeMem: LONGINT;
  551.     {$IFC NOT GENERATINGCFM}
  552.     INLINE $3F3C, $0018, $A88F;
  553.     {$ENDC}
  554. PROCEDURE MFTempHLock(h: Handle; VAR resultCode: OSErr);
  555.     {$IFC NOT GENERATINGCFM}
  556.     INLINE $3F3C, $001E, $A88F;
  557.     {$ENDC}
  558. PROCEDURE MFTempHUnlock(h: Handle; VAR resultCode: OSErr);
  559.     {$IFC NOT GENERATINGCFM}
  560.     INLINE $3F3C, $001F, $A88F;
  561.     {$ENDC}
  562. PROCEDURE MFTempDisposHandle(h: Handle; VAR resultCode: OSErr);
  563.     {$IFC NOT GENERATINGCFM}
  564.     INLINE $3F3C, $0020, $A88F;
  565.     {$ENDC}
  566. FUNCTION MFTopMem: Ptr;
  567.     {$IFC NOT GENERATINGCFM}
  568.     INLINE $3F3C, $0016, $A88F;
  569.     {$ENDC}
  570. PROCEDURE ResrvMem(cbNeeded: Size);
  571.     {$IFC NOT GENERATINGCFM}
  572.     INLINE $201F, $A040;
  573.     {$ENDC}
  574. PROCEDURE DisposPtr(p: Ptr);
  575.     {$IFC NOT GENERATINGCFM}
  576.     INLINE $205F, $A01F;
  577.     {$ENDC}
  578. PROCEDURE DisposHandle(h: Handle);
  579.     {$IFC NOT GENERATINGCFM}
  580.     INLINE $205F, $A023;
  581.     {$ENDC}
  582. PROCEDURE ReallocHandle(h: Handle; byteCount: Size);
  583.     {$IFC NOT GENERATINGCFM}
  584.     INLINE $201F, $205F, $A027;
  585.     {$ENDC}
  586. {$ENDC}
  587. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  588. {$ENDC}
  589. {$ENDC}
  590. {$ALIGN RESET}
  591. {$POP}
  592.  
  593. {$SETC UsingIncludes := MemoryIncludes}
  594.  
  595. {$ENDC} {__MEMORY__}
  596.  
  597. {$IFC NOT UsingIncludes}
  598.  END.
  599. {$ENDC}
  600.